#include <iostream>
#include <thread>
// #include <mutex>
// #include <condition_variable>
#include <unistd.h>
using namespace std;

#include <pthread.h>
#include<semaphore.h>

pthread_mutex_t mutex;
pthread_cond_t condition;
bool flag = false;

void *threadARoutine(void *args)
{
    while (true)
    {
        pthread_mutex_lock(&mutex);
        if (!flag)
        {
            flag = true;
            pthread_cond_signal(&condition);
            pthread_cond_wait(&condition, &mutex);
        }
        cout << "我是线程A" << endl;
        sleep(1);
        pthread_mutex_unlock(&mutex);
    }
    return nullptr;
}

void *threadBRoutine(void *args)
{
    while (true)
    {
        pthread_mutex_lock(&mutex);
        if (flag)
        {
            flag = false;
            pthread_cond_signal(&condition);
            pthread_cond_wait(&condition, &mutex);
        }
        cout << "我是线程B" << endl;
        sleep(1);
        pthread_mutex_unlock(&mutex);
    }
    return nullptr;
}

int main()
{
    pthread_mutex_init(&mutex, nullptr);
    pthread_cond_init(&condition, nullptr);
    pthread_t tA, tB;
    pthread_create(&tA, nullptr, threadARoutine, nullptr);
    pthread_create(&tB, nullptr, threadBRoutine, nullptr);

    pthread_join(tA, nullptr);
    pthread_join(tB, nullptr);
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&condition);
    return 0;
}



// int main()
// {
//     mutex m;
//     condition_variable cv;
//     bool flag = false;

//     thread ta([&]()
//               {
//                   while (true)
//                   {
//                         if(!flag)
//                         {
//                             unique_lock<mutex> lk(m);
//                             flag = true;
//                             cout << "我是线程A" << endl;
//                             cv.notify_one();
//                             cv.wait(lk);
//                             sleep(1);
//                         }

//                   } });

//     thread tb([&]()
//               {
//                 while(true)
//                 {
//                     if(flag)
//                     {
//                         unique_lock<mutex> lk(m);
//                         flag = false;
//                         cout << "我是线程B" << endl;
//                         cv.notify_one();
//                         cv.wait(lk);
//                         sleep(1);
//                     }
//                 } });

//     ta.join();
//     tb.join();
//     return 0;
// }

// int main()
// {
//     try
//     {
//         // 实现两个线程交替打印奇偶数
//         int n = 100;
//         mutex m;
//         int i = 1;
//         condition_variable cv;
//         thread t1([&]()
//                   {
// 		while (i<n)
// 		{
// 			// 使用unique_lock类来阻塞线程
// 			unique_lock<mutex> lk(m);
// 			// 等待i%2==1
// 			cv.wait(lk, [&]() {return i % 2 == 1; });
// 			// 打印当前线程的id
// 			cout << this_thread::get_id()<<"[1]:" << i << endl;
// 			i++;
// 			// 释放锁
// 			lk.unlock();
// 			// 通知cv
// 			cv.notify_one();
// 		} });
//         thread t2([&]()
//                   {
// 		while (i < n)
// 		{
// 			// 使用unique_lock类来阻塞线程
// 			unique_lock<mutex> lk(m);
// 			// 等待i%2==0
// 			cv.wait(lk, [&]() {return i % 2 == 0; });
// 			// 打印当前线程的id
// 			cout << this_thread::get_id() << "[2]:" << i << endl;
// 			i++;
// 			// 释放锁
// 			lk.unlock();
// 			// 通知cv
// 			cv.notify_one();
// 		} });
//         // 等待t1和t2线程结束
//         t1.join();
//         t2.join();
//     }
//     catch (const std::exception &e)
//     {
//         std::cerr << e.what() << '\n';
//     }
//     return 0;
// }
